home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 June / CHIP Haziran 2001.iso / prog / haziran / 19 / setup.exe / data.z / int_io.c < prev    next >
C/C++ Source or Header  |  2001-04-11  |  4KB  |  152 lines
  1. ////////////////////////////////////////////////////////////////
  2. // File - INT_IO.C
  3. //
  4. // This is a skeleton driver for an ISA card. The driver 
  5. // implements IO port access and interrupt handler installation.
  6. // 
  7. ////////////////////////////////////////////////////////////////
  8.  
  9. #include "../../include/windrvr.h"
  10. #include "../../include/windrvr_int_thread.h"
  11. #include <stdio.h>
  12.  
  13. // put your IO range here (this example 0x378-0x37a)
  14. enum {MY_IO_BASE = 0x378};
  15. enum {MY_IO_SIZE = 0x3};
  16. // put your IRQ number to install here (this example IRQ 5)
  17. enum {MY_IRQ = 5};
  18.  
  19. // global WinDriver handle
  20. HANDLE hWD;
  21.  
  22. // interrupt structure
  23. WD_INTERRUPT Intrp;
  24.  
  25. static char line[256];
  26.  
  27. // this is equivalent to the assember "inp" command
  28. BYTE IO_ReadByte(DWORD dwIOAddr)
  29. {
  30.     WD_TRANSFER trns;
  31.     BZERO(trns);
  32.     trns.cmdTrans = RP_BYTE; // R-Read P-Port BYTE
  33.     trns.dwPort = dwIOAddr;
  34.     WD_Transfer( hWD, &trns); // Perform read
  35.     return trns.Data.Byte;
  36. }
  37.  
  38. // this is equivalent to the assember "outp" command
  39. void IO_WriteByte(DWORD dwIOAddr, BYTE bData)
  40. {
  41.     WD_TRANSFER trns;
  42.     BZERO(trns);
  43.     trns.cmdTrans = WP_BYTE; // R-Write P-Port BYTE
  44.     trns.dwPort = dwIOAddr;
  45.     trns.Data.Byte = bData;
  46.     WD_Transfer( hWD, &trns); // Perform write
  47. }
  48.  
  49. void IO_ReadByteString(DWORD dwIOAddr, PBYTE pBuf, DWORD dwBytes)
  50. {
  51.     WD_TRANSFER trns;
  52.     BZERO(trns);
  53.     trns.cmdTrans = RP_SBYTE; // R-Read, P-Port, S-String BYTE
  54.     trns.dwPort = dwIOAddr;
  55.     trns.dwBytes = dwBytes;
  56.     trns.fAutoinc = FALSE;
  57.     trns.dwOptions = 0;
  58.     trns.Data.pBuffer = pBuf;
  59.     WD_Transfer( hWD, &trns); // Perform read
  60. }
  61.  
  62. void IO_WriteByteString(DWORD dwIOAddr, PBYTE pBuf, DWORD dwBytes)
  63. {
  64.     WD_TRANSFER trns;
  65.     BZERO(trns);
  66.     trns.cmdTrans = WP_SBYTE; // W-Write, P-Port, S-String BYTE
  67.     trns.dwPort = dwIOAddr;
  68.     trns.dwBytes = dwBytes;
  69.     trns.fAutoinc = FALSE;
  70.     trns.dwOptions = 0;
  71.     trns.Data.pBuffer = pBuf;
  72.     WD_Transfer( hWD, &trns); // Perform write
  73. }
  74.  
  75. // interrupt handler routine. you can use pData to pass information from InterruptThreadEnable()
  76. VOID interrupt_handler (PVOID pData)
  77. {
  78.     // do your interrupt routine here 
  79.     printf ("Got interrupt %d\n", Intrp.dwCounter);
  80. }
  81.  
  82. int main()
  83. {
  84.     WD_CARD_REGISTER cardReg;
  85.     WD_VERSION verBuf;
  86.  
  87.     hWD = INVALID_HANDLE_VALUE;
  88.     hWD = WD_Open();
  89.     if (hWD==INVALID_HANDLE_VALUE)
  90.     {
  91.         printf ("error opening WINDRVR\n");
  92.         return 0;
  93.     }
  94.  
  95.     BZERO(verBuf);
  96.     WD_Version (hWD, &verBuf);
  97.     printf (WD_PROD_NAME " version - %s\n", verBuf.cVer);
  98.     if (verBuf.dwVer<WD_VER)
  99.     {
  100.         printf ("error incorrect WINDRVR version. needs ver %d\n",WD_VER);
  101.         WD_Close(hWD);
  102.         return 0;
  103.     }
  104.  
  105.     BZERO(cardReg);
  106.     cardReg.Card.dwItems = 2;
  107.     cardReg.Card.Item[0].item = ITEM_INTERRUPT;
  108.     cardReg.Card.Item[0].fNotSharable = TRUE;
  109.     cardReg.Card.Item[0].I.Int.dwInterrupt = MY_IRQ;
  110.     cardReg.Card.Item[0].I.Int.dwOptions = 0;
  111.     cardReg.Card.Item[1].item = ITEM_IO;
  112.     cardReg.Card.Item[1].fNotSharable = TRUE;
  113.     cardReg.Card.Item[1].I.IO.dwAddr = MY_IO_BASE;
  114.     cardReg.Card.Item[1].I.IO.dwBytes = MY_IO_SIZE;
  115.     cardReg.fCheckLockOnly = FALSE;
  116.     WD_CardRegister (hWD, &cardReg);
  117.     if (cardReg.hCard==0)
  118.     {
  119.         printf ("Failed locking device");
  120.     }
  121.     else
  122.     {
  123.         HANDLE thread_handle;
  124.     
  125.         BZERO(Intrp);
  126.         Intrp.hInterrupt = cardReg.Card.Item[0].I.Int.hInterrupt;
  127.         Intrp.Cmd = NULL;
  128.         Intrp.dwCmds = 0;
  129.         Intrp.dwOptions = 0;
  130.         printf ("starting interrupt thread\n");
  131.         // this calls WD_IntEnable() and creates an interrupt handler thread
  132.         if (!InterruptThreadEnable(&thread_handle, hWD, &Intrp, interrupt_handler, NULL))
  133.         {
  134.             printf ("failed enabling interrupt\n");
  135.         }
  136.         else
  137.         {
  138.             // call your driver code here 
  139.             printf ("Press Enter to uninstall interrupt\n");
  140.             fgets(line, sizeof(line), stdin);
  141.             
  142.             // this calls WD_IntDisable()
  143.             InterruptThreadDisable(thread_handle);
  144.         }
  145.         WD_CardUnregister(hWD, &cardReg);
  146.     }
  147.  
  148.     WD_Close(hWD);
  149.     return 0;
  150. }
  151.  
  152.